package com.loong.android.views.utils;

import static com.loong.android.views.LonView.WRAP_CONTENT;

import android.content.Context;
import android.graphics.Bitmap;
import android.os.Build;
import android.os.Handler;
import android.os.Looper;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;

import com.loong.android.utils.CharSequenceUtils;
import com.loong.android.views.LonView;

public class ViewUtils {

    /**
     * 判断对象是否为视图类的对象(android.view.View类或继承自android.view.View的所有子类的对象)
     * @param obj 带判断的对象
     */
    public static boolean isView(Object obj) {
        return obj instanceof View;
    }

    /**
     * 判断对象是否为视图组类的对象(android.view.ViewGroup类或继承自android.view.ViewGroup的所有子类的对象)
     * @param obj 带判断的对象
     */
    public static boolean isViewGroup(Object obj) {
        return obj instanceof ViewGroup;
    }

    /**
     * 读取布局id转为视图对象
     *
     * @param context 上下文
     * @param resId   布局id
     * @param root    需要添加到的根视图对象，可以为空
     */
    public static View toView(Context context, int resId, ViewGroup root) {
        return LayoutInflater.from(context).inflate(resId, root);
    }

    /**
     * 读取布局id转为视图对象
     *
     * @param context      上下文
     * @param resId        布局id
     * @param root         需要添加到的根视图对象，可以为空
     * @param attachToRoot 是否附着到根视图上
     */
    public static View toView(Context context, int resId, ViewGroup root, boolean attachToRoot) {
        return LayoutInflater.from(context).inflate(resId, root, attachToRoot);
    }

    /**
     * dp转px
     *
     * @param context 上下文
     * @param dp      dp值
     */
    public static int dp2px(Context context, float dp) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dp * scale + 0.5f);
    }

    /**
     * px转dp
     *
     * @param context 上下文
     * @param px      px值
     */
    public static int px2dp(Context context, float px) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (px / scale + 0.5f);
    }

    /**
     * sp转px
     *
     * @param context 上下文
     * @param sp      sp值
     */
    public static int sp2px(Context context, float sp) {
        final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
        return (int) (sp * fontScale + 0.5f);
    }

    /**
     * px转sp
     *
     * @param context 上下文
     * @param px      px值
     */
    public static int px2sp(Context context, float px) {
        final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
        return (int) (px / fontScale + 0.5f);
    }

    /**
     * 从指定视图对象中载入其子视图
     * @param view 视图对象
     * @param viewId 视图id
     */
    public static <T> T loadView(View view, int viewId) {
        return (T) view.findViewById(viewId);
    }

    /**
     * 从指定视图对象中载入其子视图，并设置视图的单击事件
     * @param view 视图对象
     * @param viewId 视图id
     */
    public static <T> T loadView(View view, int viewId, LonView.ClickCallback clickEvent) {
        View v = view.findViewById(viewId);
        if(v instanceof ViewTemplate) {
            ((ViewTemplate) v).setOnClick(clickEvent);
        }
        return (T) v;
    }

    /**
     * 获取视图的宽度
     *
     * @param view 视图对象
     */
    public static int width(View view) {
        return view.getWidth();
    }

    /**
     * 设置视图的高度
     *
     * @param view 视图对象
     * @param w    宽度值
     */
    public static void width(View view, int w) {
        ViewGroup.LayoutParams params = view.getLayoutParams();
        if (params == null) params = new ViewGroup.LayoutParams(WRAP_CONTENT, WRAP_CONTENT);
        params.width = w;
        view.setLayoutParams(params);
    }

    /**
     * 获取视图的高度
     *
     * @param view 视图对象
     */
    public static int height(View view) {
        return view.getHeight();
    }

    /**
     * 设置视图的高度
     *
     * @param view 视图对象
     * @param h    高度值
     */
    public static void height(View view, int h) {
        ViewGroup.LayoutParams params = view.getLayoutParams();
        if (params == null) params = new ViewGroup.LayoutParams(WRAP_CONTENT, WRAP_CONTENT);
        params.height = h;
        view.setLayoutParams(params);
    }

    /**
     * 设置视图的宽度和高度
     *
     * @param view 视图对象
     * @param w    宽度值
     * @param h    高度值
     */
    public static void setWidthHeight(View view, int w, int h) {
        ViewGroup.LayoutParams params = view.getLayoutParams();
        if (params == null) params = new ViewGroup.LayoutParams(WRAP_CONTENT, WRAP_CONTENT);
        params.width = w;
        params.height = h;
        view.setLayoutParams(params);
    }

    /**
     * 设置视图的最小宽度
     *
     * @param view 视图对象
     * @param w    宽度值
     */
    public static void minWidth(View view, int w) {
        view.setMinimumWidth(w);
    }

    /**
     * 获取视图的最小宽度
     *
     * @param view 视图对象
     */
    public static int minWidth(View view) {
        return view.getMinimumWidth();
    }

    /**
     * 设置视图的最小宽度
     *
     * @param view 视图对象
     * @param h    高度值
     */
    public static void minHeight(View view, int h) {
        view.setMinimumHeight(h);
    }

    /**
     * 获取视图最小高度
     *
     * @param view 视图对象
     */
    public static int minHeight(View view) {
        return view.getMinimumHeight();
    }

    /**
     * 设置视图描述内容
     *
     * @param view 视图对象
     * @param des  描述内容
     */
    public static void description(View view, String des) {
        view.setContentDescription(des);
    }

    /**
     * 获取视图描述内容
     *
     * @param view 视图对象
     */
    public static String description(View view) {
        return CharSequenceUtils.getText(view.getContentDescription());
    }

    /**
     * 置视图的标签数据
     *
     * @param view 视图对象
     * @param t 数据
     */
    public static void tag(View view, Object t) {
        view.setTag(t);
    }

    /**
     * 置视图的标签数据
     *
     * @param view 视图对象
     * @param key 键名
     * @param t   数据
     */
    public static void tag(View view, int key, Object t) {
        view.setTag(key, t);
    }

    /**
     * 取视图的标签数据
     *
     * @param view 视图对象
     */
    public static Object tag(View view) {
        return view.getTag();
    }

    /**
     * 取视图的标签数据
     *
     * @param view 视图对象
     * @param key 键名
     */
    public static Object tag(View view, int key) {
        return view.getTag(key);
    }

    /**
     * 设置视图的透明度
     *
     * @param view 视图对象
     * @param a 透明度，0-1
     */
    public static void alpha(View view, float a) {
        view.setAlpha(a);
    }

    /**
     * 取视图的透明度
     *
     * @param view 视图对象
     * @return 0-1
     */
    public static float alpha(View view) {
        return view.getAlpha();
    }

    /**
     * 置视图的内边距
     *
     * @param view 视图对象
     * @param left   左内边距
     * @param top    上内边距
     * @param right  右内边距
     * @param bottom 下内边距
     */
    public static void padding(View view, int left, int top, int right, int bottom) {
        view.setPadding(left, top, right, bottom);
    }

    /**
     * 置视图水平方向的内边距
     *
     * @param view 视图对象
     * @param left  左内边距
     * @param right 上内边距
     */
    public static void paddingX(View view, int left, int right) {
        view.setPadding(left, view.getPaddingTop(), right, view.getPaddingBottom());
    }

    /**
     * 置视图垂直方向的内边距
     *
     * @param view 视图对象
     * @param top    上内边距
     * @param bottom 下内边距
     */
    public static void paddingY(View view, int top, int bottom) {
        view.setPadding(view.getPaddingLeft(), top, view.getPaddingRight(), bottom);
    }

    /**
     * 置视图的左内边距
     *
     * @param view 视图对象
     * @param val 值
     */
    public static void paddingLeft(View view, int val) {
        view.setPadding(val, view.getPaddingTop(), view.getPaddingRight(), view.getPaddingBottom());
    }

    /**
     * 取视图的左内边距
     * @param view 视图对象
     */
    public static int paddingLeft(View view) {
        return view.getPaddingLeft();
    }

    /**
     * 置视图的上内边距
     *
     * @param view 视图对象
     * @param val 值
     */
    public static void paddingTop(View view, int val) {
        view.setPadding(view.getPaddingTop(), val, view.getPaddingRight(), view.getPaddingBottom());
    }

    /**
     * 取视图的上内边距
     * @param view 视图对象
     */
    public static int paddingTop(View view) {
        return view.getPaddingTop();
    }

    /**
     * 置视图的右内边距
     *
     * @param view 视图对象
     * @param val 值
     */
    public static void paddingRight(View view, int val) {
        view.setPadding(view.getPaddingTop(), view.getPaddingTop(), val, view.getPaddingBottom());
    }

    /**
     * 取视图的右内边距
     * @param view 视图对象
     */
    public static int paddingRight(View view) {
        return view.getPaddingRight();
    }

    /**
     * 置视图的下内边距
     *
     * @param view 视图对象
     * @param val 值
     */
    public static void paddingBottom(View view, int val) {
        view.setPadding(view.getPaddingTop(), view.getPaddingTop(), view.getPaddingRight(), val);
    }

    /**
     * 取视图的下内边距
     * @param view 视图对象
     */
    public static int paddingBottom(View view) {
        return view.getPaddingBottom();
    }

    private static ViewGroup.MarginLayoutParams getLp(View view) {
        ViewGroup.MarginLayoutParams layoutParams = (ViewGroup.MarginLayoutParams) view.getLayoutParams();
        if (layoutParams == null) layoutParams =
                new ViewGroup.MarginLayoutParams(view.getWidth(), view.getHeight());
        return layoutParams;
    }

    /**
     * 置视图的外边距
     *
     * @param view 视图对象
     * @param left   左外边距
     * @param top    上外边距
     * @param right  右外边距
     * @param bottom 下外边距
     */
    public static void margin(View view, int left, int top, int right, int bottom) {
        ViewGroup.MarginLayoutParams layoutParams = getLp(view);
        layoutParams.leftMargin = left;
        layoutParams.topMargin = top;
        layoutParams.rightMargin = right;
        layoutParams.bottomMargin = bottom;
        view.setLayoutParams(layoutParams);
    }

    /**
     * 置视图水平方向的外边距
     *
     * @param view 视图对象
     * @param left  左外边距
     * @param right 右外边距
     */
    public static void marginX(View view, int left, int right) {
        ViewGroup.MarginLayoutParams layoutParams = getLp(view);
        layoutParams.leftMargin = left;
        layoutParams.rightMargin = right;
        view.setLayoutParams(layoutParams);
    }

    /**
     * 置视图垂直方向的外边距
     *
     * @param view 视图对象
     * @param top    上外边距
     * @param bottom 下外边距
     */
    public static void marginY(View view, int top, int bottom) {
        ViewGroup.MarginLayoutParams layoutParams = getLp(view);
        layoutParams.topMargin = top;
        layoutParams.bottomMargin = bottom;
        view.setLayoutParams(layoutParams);
    }

    /**
     * 置视图的左外边距
     *
     * @param view 视图对象
     * @param val 值
     */
    public static void marginLeft(View view, int val) {
        ViewGroup.MarginLayoutParams layoutParams = getLp(view);
        layoutParams.leftMargin = val;
        view.setLayoutParams(layoutParams);
    }

    /**
     * 取视图的左外边距
     * @param view 视图对象
     */
    public static int marginLeft(View view) {
        return getLp(view).leftMargin;
    }

    /**
     * 置视图的上外边距
     *
     * @param view 视图对象
     * @param val 值
     */
    public static void marginTop(View view, int val) {
        ViewGroup.MarginLayoutParams layoutParams = getLp(view);
        layoutParams.topMargin = val;
        view.setLayoutParams(layoutParams);
    }

    /**
     * 取视图的上外边距
     * @param view 视图对象
     */
    public static int marginTop(View view) {
        return getLp(view).topMargin;
    }

    /**
     * 置视图的右外边距
     *
     * @param view 视图对象
     * @param val 值
     */
    public static void marginRight(View view, int val) {
        ViewGroup.MarginLayoutParams layoutParams = getLp(view);
        layoutParams.rightMargin = val;
        view.setLayoutParams(layoutParams);
    }

    /**
     * 取视图的右外边距
     * @param view 视图对象
     */
    public static int marginRight(View view) {
        return getLp(view).rightMargin;
    }

    /**
     * 置视图的下外边距
     *
     * @param view 视图对象
     * @param val 值
     */
    public static void marginBottom(View view, int val) {
        ViewGroup.MarginLayoutParams layoutParams = getLp(view);
        layoutParams.bottomMargin = val;
        view.setLayoutParams(layoutParams);
    }

    /**
     * 取视图的下外边距
     * @param view 视图对象
     */
    public static int marginBottom(View view) {
        return getLp(view).bottomMargin;
    }

    /**
     * 置视图的可视状态
     *
     * @param view 视图对象
     * @param v 可视状态，GONE: 消失不占位；INVISIBLE: 隐藏; VISIBLE: 可视
     */
    public static void visibility(View view, int v) {
        view.setVisibility(v);
    }

    /**
     * 取视图的可视状态
     *
     * @param view 视图对象
     * @return GONE: 消失不占位；INVISIBLE: 隐藏; VISIBLE: 可视
     */
    public static int visibility(View view) {
        return view.getVisibility();
    }

    /**
     * 关闭视图的硬件加速
     * @param view 视图对象
     */
    public static void closeHardwareAcceleration(View view) {
        view.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
    }

    /**
     * 从视图的父布局中删除自己
     * @param view 视图对象
     */
    public static void removeSelf(View view) {
        ((ViewGroup) view.getParent()).removeView(view);
    }

    /**
     * 使视图显示到顶层
     * @param view 视图对象
     */
    public static void toTop(View view) {
        view.bringToFront();
    }

    /**
     * 取视图的上下文
     * @param view 视图对象
     */
    public static Context getViewContext(View view) {
        return view.getContext();
    }

    /**
     * 取视图id
     * @param view 视图对象
     */
    public static int getViewId(View view) {
        return view.getId();
    }

    /**
     * 置视图id，需要android api 17才能使用
     * @param view 视图对象
     */
    public static int setViewId(View view) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1)
            return 0;
        int id = View.generateViewId();
        view.setId(id);
        return id;
    }

    /**
     * 取视图的类名称
     * @param view 视图对象
     */
    public static String getViewSimpleName(View view) {
        return view.getClass().getSimpleName();
    }

    /**
     * 取视图的父布局对象
     * @param view 视图对象
     */
    public static ViewParent getParentView(View view) {
        return view.getParent();
    }

    /**
     * 取视图的父布局id
     * @param view 视图对象
     */
    public static int getParentId(View view) {
        View v = (View) view.getParent();
        if (v == null) return -1;
        return v.getId();
    }

    /**
     * 置视图的启用状态
     *
     * @param view 视图对象
     * @param enabled 是否启用
     */
    public static void setEnabled(View view, boolean enabled) {
        view.setEnabled(enabled);
    }

    /**
     * 获取视图的焦点
     * @param view 视图对象
     */
    public static void focus(View view) {
        view.requestFocus();
    }

    /**
     * 取消视图的焦点
     * @param view 视图对象
     */
    public static void blur(View view) {
        view.clearFocus();
    }

    /**
     * 置视图可否单击，默认为 false，若为 false，将无法产生click事件，onTouch事件中也无法触发弹起事件: ACTION_UP
     * 调用 setOnClick 函数后，自动置为 true
     *
     * @param view 视图对象
     * @param enable 可否
     */
    public static void clickable(View view, boolean enable) {
        view.setClickable(enable);
    }

    /**
     * 置视图可否触发长按事件，默认为 false，若为false，无法触发longClick事件
     * 调用 setOnLongClick 函数后，自动置为 true
     *
     * @param view 视图对象
     * @param enable 可否
     */
    public static void longClickable(View view, boolean enable) {
        view.setLongClickable(enable);
    }

    /**
     * 置视图可获取焦点，使得组件在非触屏设备上拥有获取焦点的能力。
     *
     * @param view 视图对象
     * @param enable 是否获取
     */
    public static void focusable(View view, boolean enable) {
        view.setFocusable(enable);
    }

    /**
     * 置视图可获取触摸屏模式的焦点，使得组件在触屏模式下获取焦点的能力
     *
     * @param view 视图对象
     * @param enable 是否获取
     */
    public static void focusableInTouchMode(View view, boolean enable) {
        view.setFocusableInTouchMode(enable);
    }

    /**
     * 设置视图的背景颜色
     *
     * @param view 视图对象
     * @param color 颜色
     */
    public static void backgroundColor(View view, int color) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).backgroundColor(color);
        }else {
            view.setBackgroundColor(color);
        }
    }

    /**
     * 取视图的背景颜色
     * @param view 视图对象
     */
    public static int backgroundColor(View view) {
        if (view instanceof ViewTemplate) {
            return ((ViewTemplate) view).backgroundColor();
        }
        return 0;
    }

    /**
     * 设置线性渐变背景
     * @param view 视图对象
     * @param x0 起点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图水平靠左的位置。
     * @param y0 起点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图垂直靠上的位置。
     * @param x1 终点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图水平靠右的位置。
     * @param y1 终点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图垂直靠下的位置。
     * @param colors 颜色数组，不同位置的颜色值
     * @param positions 位置数组，指定各个颜色的位置。设置的值范围时0-1，0表示起始位置, 1表示结束位置
     * @param mode 平铺方式，参考"TileMode"类的常量
     */
    public static void setBackgroundLinearGradient(View view, float x0, float y0, float x1, float y1, int[] colors, float[] positions, int mode) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).setBackgroundLinearGradient(x0, y0, x1, y1, colors, positions, mode);
        }
    }

    /**
     * 设置线性渐变背景
     * @param view 视图对象
     * @param x0 起点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图水平靠左的位置。
     * @param y0 起点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为0，表示在视图垂直靠上的位置。
     * @param x1 终点横坐标。0-1表示按视图宽度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图水平靠右的位置。
     * @param y1 终点纵坐标。0-1表示按视图高度比例计算，大于1和小于等于0表示固定的像素值。默认值为1，表示在视图垂直靠下的位置。
     * @param color1 开始的颜色值
     * @param color2 结束的颜色值
     * @param mode 平铺方式，参考"TileMode"类的常量
     */
    public static void setBackgroundLinearGradient(View view, float x0, float y0, float x1, float y1, int color1, int color2, int mode) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).setBackgroundLinearGradient(x0, y0, x1, y1, color1, color2, mode);
        }
    }

    /**
     * 设置环形渐变背景
     * @param view 视图对象
     * @param centerX 中心点横坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图水平方向的中间位置。
     * @param centerY 中心点纵坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图垂直方向的中间位置。
     * @param radius 环形的半径，小于0时表示按视图宽度或高度的比例计算。
     *               大于等于0表示固定的像素值；
     *               -1 <= radius < 0 时，表示按短边的比例计算；
     *               -2 <= radius < -1 时，表示按长边的比例计算。
     *               -3 <= radius < -2 时，表示按视图宽度的比例计算。
     *               -4 <= radius < -3 时，表示按视图高度的比例计算。
     *               默认值为-1，即半径为视图最短边的长度。
     * @param colors 颜色数组，不同位置的颜色值
     * @param stops 位置数组，指定各个颜色的位置。设置的值范围时0-1，0表示起始位置, 1表示结束位置
     * @param mode 平铺方式，参考"TileMode"类的常量
     */
    public static void setBackgroundRadialGradient(View view, float centerX, float centerY, float radius, int[] colors, float[] stops, int mode) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).setBackgroundRadialGradient(centerX, centerY, radius, colors, stops, mode);
        }
    }

    /**
     * 设置环形渐变背景
     * @param view 视图对象
     * @param centerX 中心点横坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图水平方向的中间位置。
     * @param centerY 中心点纵坐标，0-1表示百分比，大于1和小于等于0表示固定的像素值。默认值为0.5f，表示在视图垂直方向的中间位置。
     * @param radius 环形的半径，小于0时表示按视图宽度或高度的比例计算。
     *               大于等于0表示固定的像素值；
     *               -1 <= radius < 0 时，表示按短边的比例计算；
     *               -2 <= radius < -1 时，表示按长边的比例计算。
     *               -3 <= radius < -2 时，表示按视图宽度的比例计算。
     *               -4 <= radius < -3 时，表示按视图高度的比例计算。
     *               默认值为-1，即半径为视图最短边的长度。
     * @param centerColor 中心点颜色
     * @param edgeColor 边缘颜色
     * @param mode 平铺方式，参考"TileMode"类的常量
     */
    public static void setBackgroundRadialGradient(View view, float centerX, float centerY, float radius, int centerColor, int edgeColor, int mode) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).setBackgroundRadialGradient(centerX, centerY, radius, centerColor, edgeColor, mode);
        }
    }

    /**
     * 同时设置视图的四个角的圆角大小
     *
     * @param view 视图对象
     * @param radius 圆角大小
     */
    public static void corner(View view, int radius) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).corner(radius);
        }
    }

    /**
     * 分别设置视图四个角的圆角大小
     *
     * @param view 视图对象
     * @param topLeft     左上角
     * @param topRight    右上角
     * @param bottomRight 右下角
     * @param bottomLeft  左下角
     */
    public static void corner(View view, float topLeft, float topRight, float bottomRight, float bottomLeft) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).corner(topLeft, topRight, bottomRight, bottomLeft);
        }
    }

    /**
     * 视图有四个角，每个角有x和y两个方向的圆角大小，共8个圆角值
     *
     * @param view 视图对象
     * @param topLeftX     左上角x方向的圆角大小
     * @param topLeftY     左上角y方向的圆角大小
     * @param topRightX    右上角x方向的圆角大小
     * @param topRightY    右上角y方向的圆角大小
     * @param bottomRightX 右下角x方向的圆角大小
     * @param bottomRightY 右下角y方向的圆角大小
     * @param bottomLeftX  左下角x方向的圆角大小
     * @param bottomLeftY  左下角y方向的圆角大小
     */
    public static void corner(View view, float topLeftX, float topLeftY, float topRightX, float topRightY,
                              float bottomRightX, float bottomRightY, float bottomLeftX, float bottomLeftY) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).corner(topLeftX, topLeftY, topRightX, topRightY, bottomRightX, bottomRightY, bottomLeftX, bottomLeftY);
        }
    }

    /**
     * 置视图的边框宽度
     *
     * @param view 视图对象
     * @param w 宽度
     */
    public static void borderWidth(View view, int w) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).borderWidth(w);
        }
    }

    /**
     * 取视图的边框宽度
     * @param view 视图对象
     */
    public static int borderWidth(View view) {
        if (view instanceof ViewTemplate) {
            return ((ViewTemplate) view).borderWidth();
        }
        return 0;
    }

    /**
     * 置视图的边框颜色
     *
     * @param view 视图对象
     * @param color 颜色
     */
    public static void borderColor(View view, int color) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).borderColor(color);
        }
    }

    /**
     * 取视图的边框颜色
     * @param view 视图对象
     */
    public static int borderColor(View view) {
        if (view instanceof ViewTemplate) {
            return ((ViewTemplate) view).borderColor();
        }
        return 0;
    }

    /**
     * 取视图背景图片的位图数据
     * @param view 视图对象
     */
    public static Bitmap getBackgroundBitmap(View view) {
        if (view instanceof ViewTemplate) {
            return ((ViewTemplate) view).getBackgroundBitmap();
        }
        return null;
    }

    /**
     * 置视图的背景图片
     *
     * @param view 视图对象
     * @param resId 图片资源id
     */
    public static void background(View view, int resId) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).background(resId);
        }
    }

    /**
     * 置视图的背景图片
     *
     * @param view 视图对象
     * @param bitmap 图片位图数据
     */
    public static void background(View view, Bitmap bitmap) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).background(bitmap);
        }
    }

    /**
     * 置视图的背景图片，注意需要先申请读取文件的权限(READ_EXTERNAL_STORAGE)
     *
     * @param view 视图对象
     * @param filePath 图片文件地址
     */
    public static void background(View view, String filePath) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).background(filePath);
        }
    }

    /**
     * 置视图的背景图片
     *
     * @param view 视图对象
     * @param bytes 字节数组
     */
    public static void background(View view, byte[] bytes) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).background(bytes);
        }
    }

    /**
     * 置视图可视状态改变的事件回调
     *
     * @param view 视图对象
     * @param event 回调的接口事件
     */
    public static void setOnVisibilityChange(View view, LonView.VisibilityChangeCallback event) {
        if (!(view instanceof ViewTemplate)) return;
        ((ViewTemplate) view).setOnVisibilityChange(event);
    }

    /**
     * 置视图焦点改变的事件回调
     *
     * @param view 视图对象
     * @param event 回调的接口事件
     */
    public static void setOnFocusChange(View view, LonView.FocusChangeCallback event) {
        if (!(view instanceof ViewTemplate)) return;
        ((ViewTemplate) view).setOnFocusChange(event);
    }

    /**
     * 置视图尺寸被改变的事件回调
     *
     * @param view 视图对象
     * @param event 回调的接口事件
     */
    public static void setOnSizeChange(View view, LonView.SizeChangeCallback event) {
        if (!(view instanceof ViewTemplate)) return;
        ((ViewTemplate) view).setOnSizeChange(event);
    }

    /**
     * 置视图生命周期改变的事件回调
     *
     * @param view 视图对象
     * @param event 回调的接口事件
     */
    public static void setOnLiftChange(View view, LonView.LifeCallback event) {
        if (!(view instanceof ViewTemplate)) return;
        ((ViewTemplate) view).setOnLiftChange(event);
    }

    /**
     * 置视图被单击的回调事件
     *
     * @param view 视图对象
     * @param event 回调的接口事件
     */
    public static void setOnClick(View view, LonView.ClickCallback event) {
        if (!(view instanceof ViewTemplate)) return;
        ((ViewTemplate) view).setOnClick(event);
    }

    /**
     * 置视图被长按的回调
     *
     * @param view 视图对象
     * @param event 回调的接口事件
     */
    public static void setOnLongClick(View view, LonView.ClickCallback event) {
        if (!(view instanceof ViewTemplate)) return;
        ((ViewTemplate) view).setOnLongClick(event);
    }

    /**
     * 置视图的触摸回调
     *
     * @param view 视图对象
     * @param event 回调事件
     */
    public static void setOnTouch(View view, LonView.TouchCallback event) {
        if (!(view instanceof ViewTemplate)) return;
        ((ViewTemplate) view).setOnTouch(event);
    }

    /**
     * 开启或关闭视图的水波纹特效
     * @param view 视图对象
     * @param enable 启用状态
     */
    public static void setRippleEffectEnable(View view, boolean enable) {
        if (view instanceof ViewTemplate) {
            ((ViewTemplate) view).setRippleEffectEnable(enable);
        }
    }

    /**
     * 视图提交处理，待完成后再触发回调事件
     *
     * @param view 视图对象
     * @param event 事件回调
     */
    public static void viewPost(View view, Runnable event) {
        view.post(event);
    }

    /**
     * 视图提交处理，待完成后再触发回调事件
     *
     * @param view 视图对象
     * @param delayTime 延迟时间，单位为毫秒
     * @param event 事件回调
     */
    public static void viewPost(View view, long delayTime, Runnable event) {
        view.postDelayed(event, delayTime);
    }

    /**
     * 视图提交动画处理，待完成后再触发回调事件
     *
     * @param view 视图对象
     * @param event 事件回调
     */
    public static void viewPostOnAnimation(View view, Runnable event) {
        view.postOnAnimation(event);
    }

    /**
     * 视图提交动画处理，待完成后再触发回调事件
     *
     * @param view 视图对象
     * @param delayTime 延迟时间，单位为毫秒
     * @param event 事件回调
     */
    public static void viewPostOnAnimation(View view, long delayTime, Runnable event) {
        view.postOnAnimationDelayed(event, delayTime);
    }

    /**
     * 清空视图的所有子布局
     * @param viewGroup 容器视图对象
     */
    public static void clearChildViews(View viewGroup) {
        ((ViewGroup) viewGroup).removeAllViews();
    }

    /**
     * 删除视图指定位置上的子布局
     *
     * @param viewGroup 容器视图对象
     * @param index 位置索引
     */
    public static void removeChildView(View viewGroup, int index) {
        ((ViewGroup) viewGroup).removeViewAt(index);
    }

    /**
     * 从指定位置开始删除指定数量的子布局
     *
     * @param viewGroup 容器视图对象
     * @param startIndex 起始位置
     * @param size       欲删除的子布局数量
     */
    public static void removeChildView(View viewGroup, int startIndex, int size) {
        ((ViewGroup) viewGroup).removeViews(startIndex, size);
    }

    /**
     * 删除子布局
     *
     * @param viewGroup 容器视图对象
     * @param childView 子布局对象
     */
    public static void removeChildView(View viewGroup, View childView) {
        ((ViewGroup) viewGroup).removeView(childView);
    }

    /**
     * 取子布局
     *
     * @param viewGroup 容器视图对象
     * @param index 子布局索引
     * @return 返回子布局对象
     */
    public static View getChildView(ViewGroup viewGroup, int index) {
        return viewGroup.getChildAt(index);
    }

    /**
     * 添加子布局
     *
     *  @param viewGroup 容器视图对象
     * @param childView 子布局对象
     */
    public static void addChildView(ViewGroup viewGroup, View childView) {
        viewGroup.addView(childView);
    }

    /**
     * 将子布局插入到指定的位置
     *
     * @param viewGroup 容器视图对象
     * @param childView 子布局对象
     * @param index     位置索引
     */
    public static void addChildView(ViewGroup viewGroup, View childView, int index) {
        viewGroup.addView(childView, index);
    }

    /**
     * 取子布局总数
     * @param viewGroup 容器视图对象
     */
    public static int getChildViewSize(ViewGroup viewGroup) {
        return viewGroup.getChildCount();
    }

    /**
     * 设置视图视觉上的X属性(横坐标)。属性关系公式: X = left + translationX
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setX(View view, float val) {
        view.setX(val);
    }

    /**
     * 设置视图视觉上的Y属性(纵坐标)。属性关系公式: Y = top + translationY
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setY(View view, float val) {
        view.setY(val);
    }

    /**
     * 设置视图的Z轴位置。仅在android 5.0(api 21)及以上版本有效。属性关系公式: z = translationZ + elevation
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setZ(View view, float val) {
        if(Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return;
        view.setZ(val);
    }

    /**
     * 设置视图在Z轴的高度。仅在android 5.0(api 21)及以上版本有效。属性关系公式: elevation = z - translationZ
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setElevation(View view, float val) {
        if(Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return;
        view.setElevation(val);
    }

    /**
     * 设置视图相对于父视图左侧的偏移位置
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setLeft(View view, int val) {
        view.setLeft(val);
    }

    /**
     * 设置视图相对于父视图顶部的偏移位置
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setTop(View view, int val) {
        view.setTop(val);
    }

    /**
     * 设置视图相对于父视图右侧的偏移位置
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setRight(View view, int val) {
        view.setRight(val);
    }

    /**
     * 设置视图相对于父视图底部的偏移位置
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setBottom(View view, int val) {
        view.setBottom(val);
    }

    /**
     * 设置旋转和缩放时的中心点X
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setPivotX(View view, float val) {
        view.setPivotX(val);
    }

    /**
     * 设置旋转和缩放时的中心点Y
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setPivotY(View view, float val) {
        view.setPivotY(val);
    }

    /**
     * 旋转视图
     * @param view 操作的视图对象
     * @param val 角度值
     */
    public static void setRotation(View view, float val) {
        view.setRotation(val);
    }

    /**
     * 围绕水平轴旋转视图
     * @param view 操作的视图对象
     * @param val 角度值
     */
    public static void setRotationX(View view, float val) {
        view.setRotationX(val);
    }

    /**
     * 围绕垂直轴旋转视图
     * @param view 操作的视图对象
     * @param val 角度值
     */
    public static void setRotationY(View view, float val) {
        view.setRotationY(val);
    }

    /**
     * 设置视图相对于父视图左侧的水平位置
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setTranslationX(View view, float val) {
        view.setTranslationX(val);
    }

    /**
     * 设置视图相对于父视图顶部的垂直位置
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setTranslationY(View view, float val) {
        view.setTranslationY(val);
    }

    /**
     * 设置视图的Z轴位置。仅在android 5.0(api 21)及以上版本有效。translationZ = z - elevation
     * @param view 操作的视图对象
     * @param val 需要设置的值，单位为px
     */
    public static void setTranslationZ(View view, float val) {
        if(Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return;
        view.setTranslationZ(val);
    }

    /**
     * 设置视图围绕X轴缩放
     * @param view 操作的视图对象
     * @param val 缩放比例，1表示不缩放
     */
    public static void setScaleX(View view, float val) {
        view.setScaleX(val);
    }

    /**
     * 设置视图围绕Y轴缩放
     * @param view 操作的视图对象
     * @param val 缩放比例，1表示不缩放
     */
    public static void setScaleY(View view, float val) {
        view.setScaleY(val);
    }

    /**
     * 设置视图的激活状态
     * @param view 操作的视图对象
     * @param val 需要设置的值
     */
    public static void setActivated(View view, boolean val) {
        view.setActivated(val);
    }

    /**
     * 设置视图的选中状态
     * @param view 操作的视图对象
     * @param val 需要设置的值
     */
    public static void setSelected(View view, boolean val) {
        view.setSelected(val);
    }

    /**
     * 设置沿 Z 轴（垂直于绘制视图的 X/Y 平面）从相机到此视图的距离。相机的距离会影响 3D 变换，例如围绕 X 和 Y 轴的旋转。
     * 如果更改了 rotationX 或 rotationY 属性并且此视图很大（超过屏幕大小的一半），建议始终使用大于高度（X 轴旋转）或宽度（Y 轴旋转）的相机距离) 。
     * 当围绕 x 或 y 轴旋转时，相机与视图平面的距离会影响视图的透视失真。例如，距离远会导致视角大，旋转时视图不会有太大的透视失真。
     * 较短的距离可能会在旋转时导致更多的透视失真，并且如果旋转的视图最终部分位于相机后面，也可能导致一些绘图伪影（这就是为什么建议使用至少与视图，如果要旋转视图。）
     * 默认x相机距离取决于屏幕密度。例如，在中等密度显示器上，默认距离为 1280。在高密度显示器上，默认距离为 1920。
     * @param view 操作的视图对象
     * @param distance 相机距离
     */
    public static void setCameraDistance(View view, float distance) {
        view.setCameraDistance(distance);
    }

    public static float getX(View view) {
        return view.getX();
    }

    public static float getY(View view) {
        return view.getY();
    }

    public static float getZ(View view) {
        if(Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return 0;
        return view.getZ();
    }

    public static float getElevation(View view) {
        if(Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return 0;
        return view.getElevation();
    }

    public static int getLeft(View view) {
        return view.getLeft();
    }

    public static int getTop(View view) {
        return view.getTop();
    }

    public static int getRight(View view) {
        return view.getRight();
    }

    public static int getBottom(View view) {
        return view.getBottom();
    }

    public static float getRotation(View view) {
        return view.getRotation();
    }

    public static float getRotationX(View view) {
        return view.getRotationX();
    }

    public static float getRotationY(View view) {
        return view.getRotationY();
    }

    public static float getScaleX(View view) {
        return view.getScaleX();
    }

    public static float getScaleY(View view) {
        return view.getScaleY();
    }

    public static float getCameraDistance(View view) {
        return view.getCameraDistance();
    }

    public static int getBaseline(View view) {
        return view.getBaseline();
    }

    private final static Handler mUiThreadHandler = new Handler(Looper.getMainLooper());

    /**
     * 在主线程中执行ui操作
     * @param runnable 事件回调
     */
    public static void runOnUiThread(Runnable runnable) {
        mUiThreadHandler.post(runnable);
    }
}
